#!/usr/bin/env node

const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');

// 颜色输出函数
const colors = {
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m',
  cyan: '\x1b[36m',
  white: '\x1b[37m',
  reset: '\x1b[0m'
};

function colorLog(message, color = 'white') {
  console.log(`${colors[color]}${message}${colors.reset}`);
}

// 检查必要条件
async function checkPrerequisites() {
  colorLog('\n🔍 检查运行环境...', 'cyan');
  
  const checks = [];
  
  // 1. 检查测试图片目录
  const testImagesDir = path.join(__dirname, '../测试图片');
  if (fs.existsSync(testImagesDir)) {
    const files = fs.readdirSync(testImagesDir);
    const imageFiles = files.filter(file => {
      const ext = path.extname(file).toLowerCase();
      return ['.jpg', '.jpeg', '.png', '.bmp', '.gif'].includes(ext);
    });
    
    if (imageFiles.length > 0) {
      colorLog(`✅ 测试图片目录: 发现 ${imageFiles.length} 个图片文件`, 'green');
      checks.push({ name: '测试图片目录', status: true, count: imageFiles.length });
    } else {
      colorLog(`❌ 测试图片目录: 没有找到图片文件`, 'red');
      checks.push({ name: '测试图片目录', status: false, error: '没有图片文件' });
    }
  } else {
    colorLog(`❌ 测试图片目录不存在: ${testImagesDir}`, 'red');
    checks.push({ name: '测试图片目录', status: false, error: '目录不存在' });
  }
  
  // 2. 检查Node.js版本
  const nodeVersion = process.version;
  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
  if (majorVersion >= 14) {
    colorLog(`✅ Node.js版本: ${nodeVersion}`, 'green');
    checks.push({ name: 'Node.js版本', status: true, version: nodeVersion });
  } else {
    colorLog(`❌ Node.js版本过低: ${nodeVersion} (需要 >= 14.0.0)`, 'red');
    checks.push({ name: 'Node.js版本', status: false, error: '版本过低' });
  }
  
  // 3. 检查依赖包
  const packageJsonPath = path.join(__dirname, 'package.json');
  if (fs.existsSync(packageJsonPath)) {
    const nodeModulesPath = path.join(__dirname, 'node_modules');
    if (fs.existsSync(nodeModulesPath)) {
      colorLog(`✅ 依赖包已安装`, 'green');
      checks.push({ name: '依赖包', status: true });
    } else {
      colorLog(`⚠️  依赖包未安装，需要运行 npm install`, 'yellow');
      checks.push({ name: '依赖包', status: false, error: '需要安装' });
    }
  }
  
  // 4. 检查批量测试脚本
  const batchScriptPath = path.join(__dirname, 'batch-test-images.js');
  if (fs.existsSync(batchScriptPath)) {
    colorLog(`✅ 批量测试脚本存在`, 'green');
    checks.push({ name: '批量测试脚本', status: true });
  } else {
    colorLog(`❌ 批量测试脚本不存在: ${batchScriptPath}`, 'red');
    checks.push({ name: '批量测试脚本', status: false, error: '脚本不存在' });
  }
  
  return checks;
}

// 检查后端服务状态
async function checkBackendService() {
  colorLog('\n🌐 检查后端服务状态...', 'cyan');
  
  return new Promise((resolve) => {
    const axios = require('axios');
    const timeout = setTimeout(() => {
      colorLog(`❌ 后端服务检查超时`, 'red');
      resolve(false);
    }, 5000);
    
    axios.get('http://localhost:3000/aiimg/status')
      .then(response => {
        clearTimeout(timeout);
        if (response.data && response.data.code === 200) {
          const data = response.data.data;
          colorLog(`✅ 后端服务正常运行`, 'green');
          colorLog(`   - 模型已加载: ${data.modelLoaded ? '是' : '否'}`, data.modelLoaded ? 'green' : 'yellow');
          colorLog(`   - 系统就绪: ${data.systemReady ? '是' : '否'}`, data.systemReady ? 'green' : 'yellow');
          resolve(true);
        } else {
          colorLog(`⚠️  后端服务响应异常`, 'yellow');
          resolve(false);
        }
      })
      .catch(error => {
        clearTimeout(timeout);
        if (error.code === 'ECONNREFUSED') {
          colorLog(`❌ 后端服务未启动 (端口3000)`, 'red');
          colorLog(`   请先运行: npm start`, 'yellow');
        } else {
          colorLog(`❌ 后端服务检查失败: ${error.message}`, 'red');
        }
        resolve(false);
      });
  });
}

// 安装依赖
function installDependencies() {
  return new Promise((resolve, reject) => {
    colorLog('\n📦 正在安装依赖包...', 'cyan');
    
    const npm = spawn('npm', ['install'], {
      cwd: __dirname,
      stdio: 'inherit'
    });
    
    npm.on('close', (code) => {
      if (code === 0) {
        colorLog('✅ 依赖包安装完成', 'green');
        resolve();
      } else {
        colorLog(`❌ 依赖包安装失败 (退出代码: ${code})`, 'red');
        reject(new Error('依赖安装失败'));
      }
    });
    
    npm.on('error', (error) => {
      colorLog(`❌ 依赖包安装出错: ${error.message}`, 'red');
      reject(error);
    });
  });
}

// 运行批量测试
function runBatchTest() {
  return new Promise((resolve, reject) => {
    colorLog('\n🚀 启动批量图片测试...', 'cyan');
    colorLog('提示: 按 Ctrl+C 可以随时停止测试\n', 'yellow');
    
    const batchTest = spawn('node', ['batch-test-images.js'], {
      cwd: __dirname,
      stdio: 'inherit'
    });
    
    batchTest.on('close', (code) => {
      if (code === 0) {
        colorLog('\n🎉 批量测试完成!', 'green');
        resolve();
      } else if (code === null) {
        colorLog('\n⏹️  批量测试被用户中断', 'yellow');
        resolve();
      } else {
        colorLog(`\n❌ 批量测试失败 (退出代码: ${code})`, 'red');
        reject(new Error('批量测试失败'));
      }
    });
    
    batchTest.on('error', (error) => {
      colorLog(`❌ 批量测试出错: ${error.message}`, 'red');
      reject(error);
    });
  });
}

// 显示帮助信息
function showHelp() {
  colorLog('\n📖 批量图片测试工具', 'cyan');
  colorLog('='.repeat(50), 'cyan');
  colorLog('用法: node run-batch-test.js [选项]', 'white');
  colorLog('\n选项:', 'white');
  colorLog('  --help, -h        显示此帮助信息', 'white');
  colorLog('  --check, -c       仅检查运行环境，不执行测试', 'white');
  colorLog('  --install, -i     安装依赖后退出', 'white');
  colorLog('  --force, -f       强制运行，跳过部分检查', 'white');
  colorLog('\n说明:', 'white');
  colorLog('  此工具会自动检查运行环境，安装依赖，然后运行批量图片测试', 'white');
  colorLog('  确保测试图片存在于 ../测试图片/ 目录中', 'white');
  colorLog('  确保后端服务正在运行 (npm start)', 'white');
  colorLog('\n示例:', 'white');
  colorLog('  node run-batch-test.js            # 完整运行', 'white');
  colorLog('  node run-batch-test.js --check    # 仅检查环境', 'white');
  colorLog('  node run-batch-test.js --install  # 仅安装依赖', 'white');
}

// 主函数
async function main() {
  const args = process.argv.slice(2);
  
  // 处理命令行参数
  if (args.includes('--help') || args.includes('-h')) {
    showHelp();
    return;
  }
  
  const checkOnly = args.includes('--check') || args.includes('-c');
  const installOnly = args.includes('--install') || args.includes('-i');
  const force = args.includes('--force') || args.includes('-f');
  
  try {
    // 显示欢迎信息
    colorLog('🎯 批量图片测试工具', 'magenta');
    colorLog('='.repeat(50), 'magenta');
    
    // 检查运行环境
    const checks = await checkPrerequisites();
    
    // 检查是否有失败的检查项
    const failedChecks = checks.filter(check => !check.status);
    
    if (failedChecks.length > 0 && !force) {
      colorLog(`\n❌ 发现 ${failedChecks.length} 个问题:`, 'red');
      failedChecks.forEach(check => {
        colorLog(`   - ${check.name}: ${check.error}`, 'red');
      });
      
      // 如果只是依赖未安装，提供安装选项
      if (failedChecks.length === 1 && failedChecks[0].name === '依赖包') {
        colorLog('\n📦 是否现在安装依赖? (y/n): ', 'yellow');
        process.stdin.setRawMode(true);
        process.stdin.resume();
        process.stdin.on('data', async (key) => {
          process.stdin.setRawMode(false);
          if (key.toString().toLowerCase() === 'y') {
            try {
              await installDependencies();
              if (!checkOnly) {
                await main(); // 重新运行
              }
            } catch (error) {
              process.exit(1);
            }
          } else {
            colorLog('安装取消', 'yellow');
            process.exit(1);
          }
        });
        return;
      }
      
      colorLog('\n解决上述问题后重新运行，或使用 --force 强制运行', 'yellow');
      if (!checkOnly) process.exit(1);
    }
    
    if (checkOnly) {
      colorLog('\n✅ 环境检查完成', 'green');
      return;
    }
    
    if (installOnly) {
      await installDependencies();
      return;
    }
    
    // 检查后端服务
    const serviceOk = await checkBackendService();
    if (!serviceOk && !force) {
      colorLog('\n❌ 后端服务不可用，请先启动后端服务后重试', 'red');
      colorLog('启动命令: npm start', 'yellow');
      process.exit(1);
    }
    
    // 运行批量测试
    await runBatchTest();
    
  } catch (error) {
    colorLog(`\n💥 执行失败: ${error.message}`, 'red');
    process.exit(1);
  }
}

// 优雅退出处理
process.on('SIGINT', () => {
  colorLog('\n\n👋 程序被用户中断', 'yellow');
  process.exit(0);
});

process.on('SIGTERM', () => {
  colorLog('\n\n👋 程序被终止', 'yellow');
  process.exit(0);
});

// 运行主函数
if (require.main === module) {
  main().catch(error => {
    colorLog(`💥 程序崩溃: ${error.message}`, 'red');
    console.error(error);
    process.exit(1);
  });
}

module.exports = { main, checkPrerequisites, checkBackendService };
